home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 11 / Info-Mac_XI_Disc_1.cdr_ / Info-Mac XI Disc 1.cdr / Programs / Science & Math / MacEspresso 1.0 / espresso / cvrout.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-02-26  |  13.2 KB  |  589 lines  |  [TEXT/R*ch]
  1. /*
  2.     module: cvrout.c
  3.     purpose: cube and cover output routines
  4. */
  5.  
  6. #include "espresso.h"
  7.  
  8. void fprint_pla(fp, PLA, output_type)
  9. INOUT FILE *fp;
  10. IN pPLA PLA;
  11. IN int output_type;
  12. {
  13.     int num;
  14.     register pcube last, p;
  15.  
  16.     if ((output_type & CONSTRAINTS_type) != 0) {
  17.     output_symbolic_constraints(fp, PLA, 0);
  18.     output_type &= ~ CONSTRAINTS_type;
  19.     if (output_type == 0) {
  20.         return;
  21.     }
  22.     }
  23.  
  24.     if ((output_type & SYMBOLIC_CONSTRAINTS_type) != 0) {
  25.     output_symbolic_constraints(fp, PLA, 1);
  26.     output_type &= ~ SYMBOLIC_CONSTRAINTS_type;
  27.     if (output_type == 0) {
  28.         return;
  29.     }
  30.     }
  31.  
  32.     if (output_type == PLEASURE_type) {
  33.     pls_output(PLA);
  34.     } else if (output_type == EQNTOTT_type) {
  35.     eqn_output(PLA);
  36.     } else if (output_type == KISS_type) {
  37.     kiss_output(fp, PLA);
  38.     } else {
  39.     fpr_header(fp, PLA, output_type);
  40.  
  41.     num = 0;
  42.     if (output_type & F_type) num += (PLA->F)->count;
  43.     if (output_type & D_type) num += (PLA->D)->count;
  44.     if (output_type & R_type) num += (PLA->R)->count;
  45.     fprintf(fp, ".p %d\n", num);
  46.  
  47.     /* quick patch 01/17/85 to support TPLA ! */
  48.     if (output_type == F_type) {
  49.         foreach_set(PLA->F, last, p) {
  50.         print_cube(fp, p, "01");
  51.         }
  52.         fprintf(fp, ".e\n");
  53.     } else {
  54.         if (output_type & F_type) {
  55.         foreach_set(PLA->F, last, p) {
  56.             print_cube(fp, p, "~1");
  57.         }
  58.         }
  59.         if (output_type & D_type) {
  60.         foreach_set(PLA->D, last, p) {
  61.             print_cube(fp, p, "~2");
  62.         }
  63.         }
  64.         if (output_type & R_type) {
  65.         foreach_set(PLA->R, last, p) {
  66.             print_cube(fp, p, "~0");
  67.         }
  68.         }
  69.         fprintf(fp, ".end\n");
  70.     }
  71.     }
  72. }
  73.  
  74. void fpr_header(fp, PLA, output_type)
  75. FILE *fp;
  76. pPLA PLA;
  77. int output_type;
  78. {
  79.     register int i, var;
  80.     int first, last;
  81.  
  82.     /* .type keyword gives logical type */
  83.     if (output_type != F_type) {
  84.     fprintf(fp, ".type ");
  85.     if (output_type & F_type) putc('f', fp);
  86.     if (output_type & D_type) putc('d', fp);
  87.     if (output_type & R_type) putc('r', fp);
  88.     putc('\n', fp);
  89.     }
  90.  
  91.     /* Check for binary or multiple-valued labels */
  92.     if (cube.num_mv_vars <= 1) {
  93.     fprintf(fp, ".i %d\n", cube.num_binary_vars);
  94.     if (cube.output != -1)
  95.         fprintf(fp, ".o %d\n", cube.part_size[cube.output]);
  96.     } else {
  97.     fprintf(fp, ".mv %d %d", cube.num_vars, cube.num_binary_vars);
  98.     for(var = cube.num_binary_vars; var < cube.num_vars; var++)
  99.         fprintf(fp, " %d", cube.part_size[var]);
  100.     fprintf(fp, "\n");
  101.     }
  102.  
  103.     /* binary valued labels */
  104.     if (PLA->label != NIL(char *) && PLA->label[1] != NIL(char)
  105.         && cube.num_binary_vars > 0) {
  106.     fprintf(fp, ".ilb");
  107.     for(var = 0; var < cube.num_binary_vars; var++)
  108.         fprintf(fp, " %s", INLABEL(var));
  109.     putc('\n', fp);
  110.     }
  111.  
  112.     /* output-part (last multiple-valued variable) labels */
  113.     if (PLA->label != NIL(char *) &&
  114.         PLA->label[cube.first_part[cube.output]] != NIL(char)
  115.         && cube.output != -1) {
  116.     fprintf(fp, ".ob");
  117.     for(i = 0; i < cube.part_size[cube.output]; i++)
  118.         fprintf(fp, " %s", OUTLABEL(i));
  119.     putc('\n', fp);
  120.     }
  121.  
  122.     /* multiple-valued labels */
  123.     for(var = cube.num_binary_vars; var < cube.num_vars-1; var++) {
  124.     first = cube.first_part[var];
  125.     last = cube.last_part[var];
  126.     if (PLA->label != NULL && PLA->label[first] != NULL) {
  127.         fprintf(fp, ".label var=%d", var);
  128.         for(i = first; i <= last; i++) {
  129.         fprintf(fp, " %s", PLA->label[i]);
  130.         }
  131.         putc('\n', fp);
  132.     }
  133.     }
  134.  
  135.     if (PLA->phase != (pcube) NULL) {
  136.     first = cube.first_part[cube.output];
  137.     last = cube.last_part[cube.output];
  138.     fprintf(fp, "#.phase ");
  139.     for(i = first; i <= last; i++)
  140.         putc(is_in_set(PLA->phase,i) ? '1' : '0', fp);
  141.     fprintf(fp, "\n");
  142.     }
  143. }
  144.  
  145. void pls_output(PLA)
  146. IN pPLA PLA;
  147. {
  148.     register pcube last, p;
  149.  
  150.     printf(".option unmerged\n");
  151.     makeup_labels(PLA);
  152.     pls_label(PLA, stdout);
  153.     pls_group(PLA, stdout);
  154.     printf(".p %d\n", PLA->F->count);
  155.     foreach_set(PLA->F, last, p) {
  156.     print_expanded_cube(stdout, p, PLA->phase);
  157.     }
  158.     printf(".end\n");
  159. }
  160.  
  161.  
  162. void pls_group(PLA, fp)
  163. pPLA PLA;
  164. FILE *fp;
  165. {
  166.     int var, i, col, len;
  167.  
  168.     fprintf(fp, "\n.group");
  169.     col = 6;
  170.     for(var = 0; var < cube.num_vars-1; var++) {
  171.     fprintf(fp, " ("), col += 2;
  172.     for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
  173.         len = strlen(PLA->label[i]);
  174.         if (col + len > 75)
  175.         fprintf(fp, " \\\n"), col = 0;
  176.         else if (i != 0)
  177.         putc(' ', fp), col += 1;
  178.         fprintf(fp, "%s", PLA->label[i]), col += len;
  179.     }
  180.     fprintf(fp, ")"), col += 1;
  181.     }
  182.     fprintf(fp, "\n");
  183. }
  184.  
  185.  
  186. void pls_label(PLA, fp)
  187. pPLA PLA;
  188. FILE *fp;
  189. {
  190.     int var, i, col, len;
  191.  
  192.     fprintf(fp, ".label");
  193.     col = 6;
  194.     for(var = 0; var < cube.num_vars; var++)
  195.     for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
  196.         len = strlen(PLA->label[i]);
  197.         if (col + len > 75)
  198.         fprintf(fp, " \\\n"), col = 0;
  199.         else
  200.         putc(' ', fp), col += 1;
  201.         fprintf(fp, "%s", PLA->label[i]), col += len;
  202.     }
  203. }
  204.  
  205.  
  206.  
  207. /*
  208.     eqntott output mode -- output algebraic equations
  209. */
  210. void eqn_output(PLA)
  211. pPLA PLA;
  212. {
  213.     register pcube p, last;
  214.     register int i, var, col, len;
  215.     int x;
  216.     bool firstand, firstor;
  217.  
  218.     if (cube.output == -1)
  219.     fatal("Cannot have no-output function for EQNTOTT output mode");
  220.     if (cube.num_mv_vars != 1)
  221.     fatal("Must have binary-valued function for EQNTOTT output mode");
  222.     makeup_labels(PLA);
  223.  
  224.     /* Write a single equation for each output */
  225.     for(i = 0; i < cube.part_size[cube.output]; i++) {
  226.     printf("%s = ", OUTLABEL(i));
  227.     col = strlen(OUTLABEL(i)) + 3;
  228.     firstor = TRUE;
  229.  
  230.     /* Write product terms for each cube in this output */
  231.     foreach_set(PLA->F, last, p)
  232.         if (is_in_set(p, i + cube.first_part[cube.output])) {
  233.         if (firstor)
  234.             printf("("), col += 1;
  235.         else
  236.             printf(" | ("), col += 4;
  237.         firstor = FALSE;
  238.         firstand = TRUE;
  239.  
  240.         /* print out a product term */
  241.         for(var = 0; var < cube.num_binary_vars; var++)
  242.             if ((x=GETINPUT(p, var)) != DASH) {
  243.             len = strlen(INLABEL(var));
  244.             if (col+len > 72)
  245.                 printf("\n    "), col = 4;
  246.             if (! firstand)
  247.                 printf("&"), col += 1;
  248.             firstand = FALSE;
  249.             if (x == ZERO)
  250.                 printf("!"), col += 1;
  251.             printf("%s", INLABEL(var)), col += len;
  252.             }
  253.         printf(")"), col += 1;
  254.         }
  255.     printf(";\n\n");
  256.     }
  257. }
  258.  
  259.  
  260. char *fmt_cube(c, out_map, s)
  261. register pcube c;
  262. register char *out_map, *s;
  263. {
  264.     register int i, var, last, len = 0;
  265.  
  266.     for(var = 0; var < cube.num_binary_vars; var++) {
  267.     s[len++] = "?01-" [GETINPUT(c, var)];
  268.     }
  269.     for(var = cube.num_binary_vars; var < cube.num_vars - 1; var++) {
  270.     s[len++] = ' ';
  271.     for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
  272.         s[len++] = "01" [is_in_set(c, i) != 0];
  273.     }
  274.     }
  275.     if (cube.output != -1) {
  276.     last = cube.last_part[cube.output];
  277.     s[len++] = ' ';
  278.     for(i = cube.first_part[cube.output]; i <= last; i++) {
  279.         s[len++] = out_map [is_in_set(c, i) != 0];
  280.     }
  281.     }
  282.     s[len] = '\0';
  283.     return s;
  284. }
  285.  
  286.  
  287. void print_cube(fp, c, out_map)
  288. register FILE *fp;
  289. register pcube c;
  290. register char *out_map;
  291. {
  292.     register int i, var, ch;
  293.     int last;
  294.  
  295.     for(var = 0; var < cube.num_binary_vars; var++) {
  296.     ch = "?01-" [GETINPUT(c, var)];
  297.     putc(ch, fp);
  298.     }
  299.     for(var = cube.num_binary_vars; var < cube.num_vars - 1; var++) {
  300.     putc(' ', fp);
  301.     for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
  302.         ch = "01" [is_in_set(c, i) != 0];
  303.         putc(ch, fp);
  304.     }
  305.     }
  306.     if (cube.output != -1) {
  307.     last = cube.last_part[cube.output];
  308.     putc(' ', fp);
  309.     for(i = cube.first_part[cube.output]; i <= last; i++) {
  310.         ch = out_map [is_in_set(c, i) != 0];
  311.         putc(ch, fp);
  312.     }
  313.     }
  314.     putc('\n', fp);
  315. }
  316.  
  317.  
  318. void print_expanded_cube(fp, c, phase)
  319. register FILE *fp;
  320. register pcube c;
  321. pcube phase;
  322. {
  323.     register int i, var, ch;
  324.     char *out_map;
  325.  
  326.     for(var = 0; var < cube.num_binary_vars; var++) {
  327.     for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
  328.         ch = "~1" [is_in_set(c, i) != 0];
  329.         putc(ch, fp);
  330.     }
  331.     }
  332.     for(var = cube.num_binary_vars; var < cube.num_vars - 1; var++) {
  333.     for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
  334.         ch = "1~" [is_in_set(c, i) != 0];
  335.         putc(ch, fp);
  336.     }
  337.     }
  338.     if (cube.output != -1) {
  339.     var = cube.num_vars - 1;
  340.     putc(' ', fp);
  341.     for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
  342.         if (phase == (pcube) NULL || is_in_set(phase, i)) {
  343.         out_map = "~1";
  344.         } else {
  345.         out_map = "~0";
  346.         }
  347.         ch = out_map[is_in_set(c, i) != 0];
  348.         putc(ch, fp);
  349.     }
  350.     }
  351.     putc('\n', fp);
  352. }
  353.  
  354.  
  355. char *pc1(c) pcube c;
  356. {static char s1[256];return fmt_cube(c, "01", s1);}
  357. char *pc2(c) pcube c;
  358. {static char s2[256];return fmt_cube(c, "01", s2);}
  359.  
  360.  
  361. void debug_print(T, name, level)
  362. pcube *T;
  363. char *name;
  364. int level;
  365. {
  366.     register pcube *T1, p, temp;
  367.     register int cnt;
  368.  
  369.     cnt = CUBELISTSIZE(T);
  370.     temp = new_cube();
  371.     if (verbose_debug && level == 0)
  372.     printf("\n");
  373.     printf("%s[%d]: ord(T)=%d\n", name, level, cnt);
  374.     if (verbose_debug) {
  375.     printf("cofactor=%s\n", pc1(T[0]));
  376.     for(T1 = T+2, cnt = 1; (p = *T1++) != (pcube) NULL; cnt++)
  377.         printf("%4d. %s\n", cnt, pc1(set_or(temp, p, T[0])));
  378.     }
  379.     free_cube(temp);
  380. }
  381.  
  382.  
  383. void debug1_print(T, name, num)
  384. pcover T;
  385. char *name;
  386. int num;
  387. {
  388.     register int cnt = 1;
  389.     register pcube p, last;
  390.  
  391.     if (verbose_debug && num == 0)
  392.     printf("\n");
  393.     printf("%s[%d]: ord(T)=%d\n", name, num, T->count);
  394.     if (verbose_debug)
  395.     foreach_set(T, last, p)
  396.         printf("%4d. %s\n", cnt++, pc1(p));
  397. }
  398.  
  399.  
  400. void cprint(T)
  401. pcover T;
  402. {
  403.     register pcube p, last;
  404.  
  405.     foreach_set(T, last, p)
  406.     printf("%s\n", pc1(p));
  407. }
  408.  
  409.  
  410. int makeup_labels(PLA)
  411. pPLA PLA;
  412. {
  413.     int var, i, ind;
  414.  
  415.     if (PLA->label == (char **) NULL)
  416.     PLA_labels(PLA);
  417.  
  418.     for(var = 0; var < cube.num_vars; var++)
  419.     for(i = 0; i < cube.part_size[var]; i++) {
  420.         ind = cube.first_part[var] + i;
  421.         if (PLA->label[ind] == (char *) NULL) {
  422.         PLA->label[ind] = ALLOC(char, 15);
  423.         if (var < cube.num_binary_vars)
  424.             if ((i % 2) == 0)
  425.             (void) sprintf(PLA->label[ind], "v%d.bar", var);
  426.             else
  427.             (void) sprintf(PLA->label[ind], "v%d", var);
  428.         else
  429.             (void) sprintf(PLA->label[ind], "v%d.%d", var, i);
  430.         }
  431.     }
  432. }
  433.  
  434.  
  435. kiss_output(fp, PLA)
  436. FILE *fp;
  437. pPLA PLA;
  438. {
  439.     register pset last, p;
  440.  
  441.     foreach_set(PLA->F, last, p) {
  442.     kiss_print_cube(fp, PLA, p, "~1");
  443.     }
  444.     foreach_set(PLA->D, last, p) {
  445.     kiss_print_cube(fp, PLA, p, "~2");
  446.     }
  447. }
  448.  
  449.  
  450. kiss_print_cube(fp, PLA, p, out_string)
  451. FILE *fp;
  452. pPLA PLA;
  453. pcube p;
  454. char *out_string;
  455. {
  456.     register int i, var;
  457.     int part, x;
  458.  
  459.     for(var = 0; var < cube.num_binary_vars; var++) {
  460.     x = "?01-" [GETINPUT(p, var)];
  461.     putc(x, fp);
  462.     }
  463.  
  464.     for(var = cube.num_binary_vars; var < cube.num_vars - 1; var++) {
  465.     putc(' ', fp);
  466.     if (setp_implies(cube.var_mask[var], p)) {
  467.         putc('-', fp);
  468.     } else {
  469.         part = -1;
  470.         for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
  471.         if (is_in_set(p, i)) {
  472.             if (part != -1) {
  473.             fatal("more than 1 part in a symbolic variable\n");
  474.             }
  475.             part = i;
  476.         }
  477.         }
  478.         if (part == -1) {
  479.         putc('~', fp);    /* no parts, hope its an output ... */
  480.         } else {
  481.         (void) fputs(PLA->label[part], fp);
  482.         }
  483.     }
  484.     }
  485.  
  486.     if ((var = cube.output) != -1) {
  487.     putc(' ', fp);
  488.     for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
  489.         x = out_string [is_in_set(p, i) != 0];
  490.         putc(x, fp);
  491.     }
  492.     }
  493.  
  494.     putc('\n', fp);
  495. }
  496.  
  497. output_symbolic_constraints(fp, PLA, output_symbolic)
  498. FILE *fp;
  499. pPLA PLA;
  500. int output_symbolic;
  501. {
  502.     pset_family A;
  503.     register int i, j;
  504.     int size, var, npermute, *permute, *weight, noweight;
  505.  
  506.     if ((cube.num_vars - cube.num_binary_vars) <= 1) {
  507.     return;
  508.     }
  509.     makeup_labels(PLA);
  510.  
  511.     for(var=cube.num_binary_vars; var < cube.num_vars-1; var++) {
  512.  
  513.     /* pull out the columns for variable "var" */
  514.     npermute = cube.part_size[var];
  515.     permute = ALLOC(int, npermute);
  516.     for(i=0; i < npermute; i++) {
  517.         permute[i] = cube.first_part[var] + i;
  518.     }
  519.     A = sf_permute(sf_save(PLA->F), permute, npermute);
  520.     FREE(permute);
  521.  
  522.  
  523.     /* Delete the singletons and the full sets */
  524.     noweight = 0;
  525.     for(i = 0; i < A->count; i++) {
  526.         size = set_ord(GETSET(A,i));
  527.         if (size == 1 || size == A->sf_size) {
  528.         sf_delset(A, i--);
  529.         noweight++;
  530.         }
  531.     }
  532.  
  533.  
  534.     /* Count how many times each is duplicated */
  535.     weight = ALLOC(int, A->count);
  536.     for(i = 0; i < A->count; i++) {
  537.         RESET(GETSET(A, i), COVERED);
  538.     }
  539.     for(i = 0; i < A->count; i++) {
  540.         weight[i] = 0;
  541.         if (! TESTP(GETSET(A,i), COVERED)) {
  542.         weight[i] = 1;
  543.         for(j = i+1; j < A->count; j++) {
  544.             if (setp_equal(GETSET(A,i), GETSET(A,j))) {
  545.             weight[i]++;
  546.             SET(GETSET(A,j), COVERED);
  547.             }
  548.         }
  549.         }
  550.     }
  551.  
  552.  
  553.     /* Print out the contraints */
  554.     if (! output_symbolic) {
  555.         (void) fprintf(fp,
  556.         "# Symbolic constraints for variable %d (Numeric form)\n", var);
  557.         (void) fprintf(fp, "# unconstrained weight = %d\n", noweight);
  558.         (void) fprintf(fp, "num_codes=%d\n", cube.part_size[var]);
  559.         for(i = 0; i < A->count; i++) {
  560.         if (weight[i] > 0) {
  561.             (void) fprintf(fp, "weight=%d: ", weight[i]);
  562.             for(j = 0; j < A->sf_size; j++) {
  563.             if (is_in_set(GETSET(A,i), j)) {
  564.                 (void) fprintf(fp, " %d", j);
  565.             }
  566.             }
  567.             (void) fprintf(fp, "\n");
  568.         }
  569.         }
  570.     } else {
  571.         (void) fprintf(fp,
  572.         "# Symbolic constraints for variable %d (Symbolic form)\n", var);
  573.         for(i = 0; i < A->count; i++) {
  574.         if (weight[i] > 0) {
  575.             (void) fprintf(fp, "#   w=%d: (", weight[i]);
  576.             for(j = 0; j < A->sf_size; j++) {
  577.             if (is_in_set(GETSET(A,i), j)) {
  578.                 (void) fprintf(fp, " %s",
  579.                 PLA->label[cube.first_part[var]+j]);
  580.             }
  581.             }
  582.             (void) fprintf(fp, " )\n");
  583.         }
  584.         }
  585.         FREE(weight);
  586.     }
  587.     }
  588. }
  589.